home *** CD-ROM | disk | FTP | other *** search
/ Champak 122 / Vol 122.iso / games / gem_stri.swf / scripts / DefineSprite_286 / frame_12 / DoAction.as
Encoding:
Text File  |  2011-01-06  |  73.7 KB  |  1,627 lines

  1. var ┬º\x01┬º = 74;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 74)
  6.    {
  7.       set("\x01",eval("\x01") - 34);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 774)
  12.    {
  13.       set("\x01",eval("\x01") - 702);
  14.       ┬º┬ºpush(true);
  15.       continue;
  16.    }
  17.    if(eval("\x01") == 781)
  18.    {
  19.       set("\x01",eval("\x01") - 507);
  20.       break;
  21.    }
  22.    if(eval("\x01") == 951)
  23.    {
  24.       set("\x01",eval("\x01") - 753);
  25.       while(true)
  26.       {
  27.          set(┬º┬ºpop(),eval(┬º┬ºpop()) + 84);
  28.          if(┬º┬ºpop())
  29.          {
  30.             set("\x01",eval("\x01") + 660);
  31.          }
  32.          while(eval("\x01") == 672)
  33.          {
  34.             set("\x01",eval("\x01") - 33);
  35.             ┬º┬ºpush(true);
  36.          }
  37.       }
  38.       addr2771:
  39.    }
  40.    else
  41.    {
  42.       if(eval("\x01") == 759)
  43.       {
  44.          set("\x01",eval("\x01") - 359);
  45.          ┬º┬ºpush(true);
  46.          continue;
  47.       }
  48.       if(eval("\x01") == 949)
  49.       {
  50.          set("\x01",eval("\x01") + 2);
  51.          if(┬º┬ºpop())
  52.          {
  53.             set("\x01",eval("\x01") - 753);
  54.          }
  55.          continue;
  56.       }
  57.       if(eval("\x01") == 742)
  58.       {
  59.          set("\x01",eval("\x01") + 111);
  60.          ┬º┬ºpush(┬º┬ºpop() % ┬º┬ºpop());
  61.          break;
  62.       }
  63.       if(eval("\x01") != 871)
  64.       {
  65.          if(eval("\x01") == 40)
  66.          {
  67.             set("\x01",eval("\x01") + 702);
  68.             if(┬º┬ºpop())
  69.             {
  70.                set("\x01",eval("\x01") + 111);
  71.             }
  72.          }
  73.          else
  74.          {
  75.             if(eval("\x01") == 950)
  76.             {
  77.                set("\x01",eval("\x01") - 166);
  78.                break;
  79.             }
  80.             if(eval("\x01") == 853)
  81.             {
  82.                set("\x01",eval("\x01") - 36);
  83.                ┬º┬ºpush(true);
  84.             }
  85.             else if(eval("\x01") == 784)
  86.             {
  87.                set("\x01",eval("\x01") - 335);
  88.                ┬º┬ºpush(true);
  89.             }
  90.             else if(eval("\x01") == 817)
  91.             {
  92.                set("\x01",eval("\x01") + 120);
  93.                if(┬º┬ºpop())
  94.                {
  95.                   set("\x01",eval("\x01") - 294);
  96.                }
  97.             }
  98.             else if(eval("\x01") == 400)
  99.             {
  100.                set("\x01",eval("\x01") + 550);
  101.                if(┬º┬ºpop())
  102.                {
  103.                   set("\x01",eval("\x01") - 166);
  104.                }
  105.             }
  106.             else
  107.             {
  108.                if(eval("\x01") == 937)
  109.                {
  110.                   set("\x01",eval("\x01") - 294);
  111.                   break;
  112.                }
  113.                if(eval("\x01") == 449)
  114.                {
  115.                   set("\x01",eval("\x01") + 422);
  116.                   if(┬º┬ºpop())
  117.                   {
  118.                      set("\x01",eval("\x01") - 97);
  119.                   }
  120.                }
  121.                else if(eval("\x01") == 892)
  122.                {
  123.                   set("\x01",eval("\x01") + 64);
  124.                   if(┬º┬ºpop())
  125.                   {
  126.                      set("\x01",eval("\x01") - 197);
  127.                   }
  128.                }
  129.                else if(eval("\x01") == 643)
  130.                {
  131.                   set("\x01",eval("\x01") + 249);
  132.                   ┬º┬ºpush(true);
  133.                }
  134.                else
  135.                {
  136.                   if(eval("\x01") == 956)
  137.                   {
  138.                      set("\x01",eval("\x01") - 197);
  139.                      break;
  140.                   }
  141.                   if(eval("\x01") == 72)
  142.                   {
  143.                      set("\x01",eval("\x01") + 709);
  144.                      if(┬º┬ºpop())
  145.                      {
  146.                         set("\x01",eval("\x01") - 507);
  147.                      }
  148.                   }
  149.                   else
  150.                   {
  151.                      if(eval("\x01") == 198)
  152.                      {
  153.                         set("\x01",eval("\x01") + 372);
  154.                         stop();
  155.                         break;
  156.                      }
  157.                      if(eval("\x01") != 274)
  158.                      {
  159.                         break;
  160.                      }
  161.                      set("\x01",eval("\x01") + 675);
  162.                      ┬º┬ºpush(true);
  163.                   }
  164.                }
  165.             }
  166.          }
  167.          continue;
  168.       }
  169.       set("\x01",eval("\x01") - 97);
  170.       while(true)
  171.       {
  172.          if(┬º┬ºpop() == 324)
  173.          {
  174.             set("\x01",eval("\x01") + 114);
  175.             if(┬º┬ºpop())
  176.             {
  177.                set("\x01",eval("\x01") + 214);
  178.             }
  179.          }
  180.          else
  181.          {
  182.             if(eval("\x01") == 29)
  183.             {
  184.                set("\x01",eval("\x01") + 439);
  185.                play();
  186.                break loop0;
  187.             }
  188.             if(eval("\x01") == 730)
  189.             {
  190.                set("\x01",eval("\x01") - 182);
  191.                ┬º┬ºpush(true);
  192.             }
  193.             else
  194.             {
  195.                if(eval("\x01") == 733)
  196.                {
  197.                   set("\x01",eval("\x01") + 177);
  198.                   loop3:
  199.                   while(true)
  200.                   {
  201.                      set(┬º┬ºpop(),┬º┬ºpop() + 25);
  202.                      if(┬º┬ºpop())
  203.                      {
  204.                         set("\x01",eval("\x01") + 467);
  205.                      }
  206.                      while(true)
  207.                      {
  208.                         if(eval("\x01") == 956)
  209.                         {
  210.                            set("\x01",eval("\x01") - 757);
  211.                            ┬º┬ºpush(true);
  212.                         }
  213.                         else if(eval("\x01") == 187)
  214.                         {
  215.                            set("\x01",eval("\x01") - 82);
  216.                            if(┬º┬ºpop())
  217.                            {
  218.                               set("\x01",eval("\x01") + 148);
  219.                            }
  220.                         }
  221.                         else if(eval("\x01") == 253)
  222.                         {
  223.                            set("\x01",eval("\x01") + 423);
  224.                            ┬º┬ºpush(true);
  225.                         }
  226.                         else
  227.                         {
  228.                            if(eval("\x01") == 199)
  229.                            {
  230.                               break;
  231.                            }
  232.                            if(eval("\x01") == 691)
  233.                            {
  234.                               set("\x01",eval("\x01") - 413);
  235.                               ┬º┬ºpush(true);
  236.                            }
  237.                            else
  238.                            {
  239.                               if(eval("\x01") == 548)
  240.                               {
  241.                                  set("\x01",eval("\x01") - 360);
  242.                                  break loop0;
  243.                               }
  244.                               if(eval("\x01") == 188)
  245.                               {
  246.                                  set("\x01",eval("\x01") - 1);
  247.                                  ┬º┬ºpush(true);
  248.                               }
  249.                               else
  250.                               {
  251.                                  if(eval("\x01") == 834)
  252.                                  {
  253.                                     set("\x01",eval("\x01") - 65);
  254.                                     break loop0;
  255.                                  }
  256.                                  if(eval("\x01") == 105)
  257.                                  {
  258.                                     break loop3;
  259.                                  }
  260.                                  if(eval("\x01") == 887)
  261.                                  {
  262.                                     set("\x01",eval("\x01") - 53);
  263.                                     if(┬º┬ºpop())
  264.                                     {
  265.                                        set("\x01",eval("\x01") - 65);
  266.                                     }
  267.                                  }
  268.                                  else if(eval("\x01") == 278)
  269.                                  {
  270.                                     set("\x01",eval("\x01") + 270);
  271.                                     if(┬º┬ºpop())
  272.                                     {
  273.                                        set("\x01",eval("\x01") - 360);
  274.                                     }
  275.                                  }
  276.                                  else if(eval("\x01") == 676)
  277.                                  {
  278.                                     set("\x01",eval("\x01") + 234);
  279.                                     if(┬º┬ºpop())
  280.                                     {
  281.                                        set("\x01",eval("\x01") - 341);
  282.                                     }
  283.                                  }
  284.                                  else if(eval("\x01") == 769)
  285.                                  {
  286.                                     set("\x01",eval("\x01") + 59);
  287.                                     ┬º┬ºpush(true);
  288.                                  }
  289.                                  else if(eval("\x01") == 569)
  290.                                  {
  291.                                     set("\x01",eval("\x01") + 318);
  292.                                     ┬º┬ºpush(true);
  293.                                  }
  294.                                  else
  295.                                  {
  296.                                     if(eval("\x01") == 910)
  297.                                     {
  298.                                        set("\x01",eval("\x01") - 341);
  299.                                        break loop0;
  300.                                     }
  301.                                     if(eval("\x01") == 224)
  302.                                     {
  303.                                        set("\x01",eval("\x01") + 467);
  304.                                        break loop0;
  305.                                     }
  306.                                     if(eval("\x01") != 828)
  307.                                     {
  308.                                        if(eval("\x01") == 98)
  309.                                        {
  310.                                           set("\x01",eval("\x01") + 875);
  311.                                           nextFrame();
  312.                                           break loop0;
  313.                                        }
  314.                                        if(eval("\x01") == 973)
  315.                                        {
  316.                                           set("\x01",eval("\x01") - 555);
  317.                                           stop();
  318.                                        }
  319.                                        break loop0;
  320.                                     }
  321.                                     set("\x01",eval("\x01") - 730);
  322.                                     if(┬º┬ºpop())
  323.                                     {
  324.                                        set("\x01",eval("\x01") + 875);
  325.                                     }
  326.                                  }
  327.                               }
  328.                            }
  329.                         }
  330.                      }
  331.                   }
  332.                   set("\x01",eval("\x01") + 148);
  333.                   break loop0;
  334.                }
  335.                if(eval("\x01") == 820)
  336.                {
  337.                   set("\x01",eval("\x01") - 464);
  338.                   break loop0;
  339.                }
  340.                if(eval("\x01") == 711)
  341.                {
  342.                   set("\x01",eval("\x01") + 22);
  343.                   if(┬º┬ºpop())
  344.                   {
  345.                      set("\x01",eval("\x01") + 177);
  346.                   }
  347.                }
  348.                else if(eval("\x01") == 75)
  349.                {
  350.                   set("\x01",eval("\x01") + 655);
  351.                }
  352.                else if(eval("\x01") == 485)
  353.                {
  354.                   set("\x01",eval("\x01") - 410);
  355.                   if(┬º┬ºpop())
  356.                   {
  357.                      set("\x01",eval("\x01") + 655);
  358.                   }
  359.                }
  360.                else
  361.                {
  362.                   if(eval("\x01") == 689)
  363.                   {
  364.                      set("\x01",eval("\x01") + 136);
  365.                      break loop0;
  366.                   }
  367.                   if(eval("\x01") == 356)
  368.                   {
  369.                      set("\x01",eval("\x01") + 544);
  370.                      ┬º┬ºpush(true);
  371.                   }
  372.                   else if(eval("\x01") == 129)
  373.                   {
  374.                      set("\x01",eval("\x01") + 195);
  375.                      ┬º┬ºpush(true);
  376.                   }
  377.                   else
  378.                   {
  379.                      if(eval("\x01") == 336)
  380.                      {
  381.                         set("\x01",eval("\x01") + 18);
  382.                         break loop0;
  383.                      }
  384.                      if(eval("\x01") == 354)
  385.                      {
  386.                         set("\x01",eval("\x01") + 523);
  387.                         ┬º┬ºpush(true);
  388.                      }
  389.                      else
  390.                      {
  391.                         if(eval("\x01") != 877)
  392.                         {
  393.                            if(eval("\x01") == 652)
  394.                            {
  395.                               set("\x01",eval("\x01") + 157);
  396.                               multipleSelection = false;
  397.                               ┬º┬ºpush("rowHeight");
  398.                               ┬º┬ºpush(20);
  399.                            }
  400.                            break loop0;
  401.                         }
  402.                         set("\x01",eval("\x01") - 77);
  403.                         if(┬º┬ºpop())
  404.                         {
  405.                            set("\x01",eval("\x01") + 24);
  406.                         }
  407.                      }
  408.                   }
  409.                }
  410.             }
  411.          }
  412.          while(true)
  413.          {
  414.             if(eval("\x01") == 412)
  415.             {
  416.                set("\x01",eval("\x01") + 73);
  417.                ┬º┬ºpush(true);
  418.                continue;
  419.             }
  420.             if(eval("\x01") == 911)
  421.             {
  422.                set("\x01",eval("\x01") - 222);
  423.                if(┬º┬ºpop())
  424.                {
  425.                   set("\x01",eval("\x01") + 136);
  426.                }
  427.                continue;
  428.             }
  429.             if(eval("\x01") == 910)
  430.             {
  431.                set("\x01",eval("\x01") + 1);
  432.                ┬º┬ºpush(true);
  433.                continue;
  434.             }
  435.             if(eval("\x01") == 919)
  436.             {
  437.                set("\x01",eval("\x01") - 228);
  438.                ┬º┬ºpush(true);
  439.                continue;
  440.             }
  441.             if(eval("\x01") == 900)
  442.             {
  443.                set("\x01",eval("\x01") - 449);
  444.                if(┬º┬ºpop())
  445.                {
  446.                   set("\x01",eval("\x01") - 322);
  447.                }
  448.                continue;
  449.             }
  450.             if(eval("\x01") == 609)
  451.             {
  452.                set("\x01",eval("\x01") + 211);
  453.                if(┬º┬ºpop())
  454.                {
  455.                   set("\x01",eval("\x01") - 464);
  456.                }
  457.                continue;
  458.             }
  459.             if(eval("\x01") == 548)
  460.             {
  461.                set("\x01",eval("\x01") + 292);
  462.                if(┬º┬ºpop())
  463.                {
  464.                   set("\x01",eval("\x01") + 79);
  465.                }
  466.                continue;
  467.             }
  468.             if(eval("\x01") == 438)
  469.             {
  470.                set("\x01",eval("\x01") + 214);
  471.                break loop0;
  472.             }
  473.             if(eval("\x01") != 840)
  474.             {
  475.                if(eval("\x01") == 800)
  476.                {
  477.                   set("\x01",eval("\x01") + 24);
  478.                   eval(┬º┬ºconstant(2))[┬º┬ºconstant(8)][┬º┬ºconstant(9)](new ┬º\┬º\┬ºconstant(7)┬º(┬º┬ºconstant(6),┬º┬ºpop()));
  479.                   eval(┬º┬ºconstant(2))[┬º┬ºconstant(8)][┬º┬ºconstant(9)](new ┬º\┬º\┬ºconstant(7)┬º(┬º┬ºconstant(11),eval(┬º┬ºconstant(10))));
  480.                   eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)] = eval(┬º┬ºconstant(2));
  481.                   break loop0;
  482.                }
  483.                if(eval("\x01") == 824)
  484.                {
  485.                   set("\x01",eval("\x01") - 113);
  486.                   ┬º┬ºpush(true);
  487.                }
  488.                else if(eval("\x01") == 468)
  489.                {
  490.                   set("\x01",eval("\x01") - 109);
  491.                   ┬º┬ºpush(true);
  492.                }
  493.                else if(eval("\x01") == 825)
  494.                {
  495.                   set("\x01",eval("\x01") - 216);
  496.                   ┬º┬ºpush(true);
  497.                }
  498.                else if(eval("\x01") == 359)
  499.                {
  500.                   set("\x01",eval("\x01") - 23);
  501.                   if(┬º┬ºpop())
  502.                   {
  503.                      set("\x01",eval("\x01") + 18);
  504.                   }
  505.                }
  506.                else
  507.                {
  508.                   if(eval("\x01") == 451)
  509.                   {
  510.                      set("\x01",eval("\x01") - 322);
  511.                      break loop0;
  512.                   }
  513.                   if(eval("\x01") != 691)
  514.                   {
  515.                      break;
  516.                   }
  517.                   set("\x01",eval("\x01") - 662);
  518.                   if(┬º┬ºpop())
  519.                   {
  520.                      set("\x01",eval("\x01") + 439);
  521.                   }
  522.                }
  523.                continue;
  524.             }
  525.             set("\x01",eval("\x01") + 79);
  526.             while(true)
  527.             {
  528.                if(┬º┬ºpop())
  529.                {
  530.                   set("\x01",eval("\x01") + 152);
  531.                   break loop0;
  532.                }
  533.                if(eval("\x01") == 663)
  534.                {
  535.                   set("\x01",eval("\x01") - 126);
  536.                   ┬º┬ºpush(true);
  537.                }
  538.                else
  539.                {
  540.                   if(eval("\x01") == 288)
  541.                   {
  542.                      set("\x01",eval("\x01") + 259);
  543.                      mx.skins.ColoredSkinElement.setColorStyle(this,"themeColor");
  544.                      break loop0;
  545.                   }
  546.                   if(eval("\x01") == 175)
  547.                   {
  548.                      set("\x01",eval("\x01") + 488);
  549.                      break loop0;
  550.                   }
  551.                   if(eval("\x01") == 197)
  552.                   {
  553.                      set("\x01",eval("\x01") + 353);
  554.                      ┬º┬ºpush(true);
  555.                   }
  556.                   else
  557.                   {
  558.                      if(eval("\x01") != 479)
  559.                      {
  560.                         break loop0;
  561.                      }
  562.                      set("\x01",eval("\x01") - 86);
  563.                      ┬º┬ºpush(true);
  564.                   }
  565.                }
  566.                while(true)
  567.                {
  568.                   if(eval("\x01") == 220)
  569.                   {
  570.                      set("\x01",eval("\x01") + 426);
  571.                      ┬º┬ºpush(true);
  572.                      continue;
  573.                   }
  574.                   if(eval("\x01") == 651)
  575.                   {
  576.                      set("\x01",eval("\x01") - 432);
  577.                      if(┬º┬ºpop())
  578.                      {
  579.                         set("\x01",eval("\x01") + 153);
  580.                      }
  581.                      continue;
  582.                   }
  583.                   if(eval("\x01") == 219)
  584.                   {
  585.                      set("\x01",eval("\x01") + 153);
  586.                      break loop0;
  587.                   }
  588.                   if(eval("\x01") == 800)
  589.                   {
  590.                      set("\x01",eval("\x01") - 606);
  591.                      if(┬º┬ºpop())
  592.                      {
  593.                         set("\x01",eval("\x01") + 3);
  594.                      }
  595.                      continue;
  596.                   }
  597.                   if(eval("\x01") == 406)
  598.                   {
  599.                      set("\x01",eval("\x01") - 203);
  600.                      if(┬º┬ºpop())
  601.                      {
  602.                         set("\x01",eval("\x01") + 645);
  603.                      }
  604.                      continue;
  605.                   }
  606.                   if(eval("\x01") == 646)
  607.                   {
  608.                      set("\x01",eval("\x01") + 290);
  609.                      if(┬º┬ºpop())
  610.                      {
  611.                         set("\x01",eval("\x01") - 457);
  612.                      }
  613.                      continue;
  614.                   }
  615.                   if(eval("\x01") == 848)
  616.                   {
  617.                      set("\x01",eval("\x01") - 197);
  618.                      ┬º┬ºpush(true);
  619.                      continue;
  620.                   }
  621.                   if(eval("\x01") == 843)
  622.                   {
  623.                      set("\x01",eval("\x01") - 43);
  624.                      ┬º┬ºpush(true);
  625.                      continue;
  626.                   }
  627.                   if(eval("\x01") == 936)
  628.                   {
  629.                      set("\x01",eval("\x01") - 457);
  630.                      break loop0;
  631.                   }
  632.                   if(eval("\x01") == 585)
  633.                   {
  634.                      set("\x01",eval("\x01") - 179);
  635.                      ┬º┬ºpush(true);
  636.                      continue;
  637.                   }
  638.                   if(eval("\x01") == 612)
  639.                   {
  640.                      set("\x01",eval("\x01") - 476);
  641.                      if(┬º┬ºpop())
  642.                      {
  643.                         set("\x01",eval("\x01") + 152);
  644.                      }
  645.                      continue;
  646.                   }
  647.                   if(eval("\x01") != 194)
  648.                   {
  649.                      if(eval("\x01") == 886)
  650.                      {
  651.                         set("\x01",eval("\x01") - 43);
  652.                         loop11:
  653.                         while(true)
  654.                         {
  655.                            set(┬º┬ºpop(),┬º┬ºpop() + 134);
  656.                            if(┬º┬ºpop())
  657.                            {
  658.                               set("\x01",eval("\x01") - 58);
  659.                            }
  660.                            while(true)
  661.                            {
  662.                               if(eval("\x01") == 81)
  663.                               {
  664.                                  set("\x01",eval("\x01") + 760);
  665.                                  ┬º┬ºpush(true);
  666.                               }
  667.                               else if(eval("\x01") == 248)
  668.                               {
  669.                                  set("\x01",eval("\x01") + 49);
  670.                                  ┬º┬ºpush(true);
  671.                               }
  672.                               else
  673.                               {
  674.                                  if(eval("\x01") == 228)
  675.                                  {
  676.                                     set("\x01",eval("\x01") + 276);
  677.                                     break loop0;
  678.                                  }
  679.                                  if(eval("\x01") == 329)
  680.                                  {
  681.                                     set("\x01",eval("\x01") + 528);
  682.                                     break loop0;
  683.                                  }
  684.                                  if(eval("\x01") == 618)
  685.                                  {
  686.                                     set("\x01",eval("\x01") - 80);
  687.                                     ┬º┬ºpush(true);
  688.                                  }
  689.                                  else if(eval("\x01") == 917)
  690.                                  {
  691.                                     set("\x01",eval("\x01") - 750);
  692.                                     ┬º┬ºpush(true);
  693.                                  }
  694.                                  else if(eval("\x01") == 483)
  695.                                  {
  696.                                     set("\x01",eval("\x01") - 100);
  697.                                     if(┬º┬ºpop())
  698.                                     {
  699.                                        set("\x01",eval("\x01") - 135);
  700.                                     }
  701.                                  }
  702.                                  else
  703.                                  {
  704.                                     if(eval("\x01") == 901)
  705.                                     {
  706.                                        set("\x01",eval("\x01") - 283);
  707.                                        break loop0;
  708.                                     }
  709.                                     if(eval("\x01") == 504)
  710.                                     {
  711.                                        set("\x01",eval("\x01") - 21);
  712.                                        ┬º┬ºpush(true);
  713.                                     }
  714.                                     else if(eval("\x01") == 57)
  715.                                     {
  716.                                        set("\x01",eval("\x01") + 272);
  717.                                        if(┬º┬ºpop())
  718.                                        {
  719.                                           set("\x01",eval("\x01") + 528);
  720.                                        }
  721.                                     }
  722.                                     else if(eval("\x01") == 297)
  723.                                     {
  724.                                        set("\x01",eval("\x01") + 604);
  725.                                        if(┬º┬ºpop())
  726.                                        {
  727.                                           set("\x01",eval("\x01") - 283);
  728.                                        }
  729.                                     }
  730.                                     else
  731.                                     {
  732.                                        if(eval("\x01") == 383)
  733.                                        {
  734.                                           set("\x01",eval("\x01") - 135);
  735.                                           break loop0;
  736.                                        }
  737.                                        if(eval("\x01") == 167)
  738.                                        {
  739.                                           set("\x01",eval("\x01") + 61);
  740.                                           if(┬º┬ºpop())
  741.                                           {
  742.                                              set("\x01",eval("\x01") + 276);
  743.                                           }
  744.                                        }
  745.                                        else
  746.                                        {
  747.                                           if(eval("\x01") == 149)
  748.                                           {
  749.                                              set("\x01",eval("\x01") + 827);
  750.                                              break loop0;
  751.                                           }
  752.                                           if(eval("\x01") == 975)
  753.                                           {
  754.                                              break loop11;
  755.                                           }
  756.                                           if(eval("\x01") == 538)
  757.                                           {
  758.                                              set("\x01",eval("\x01") - 268);
  759.                                              if(┬º┬ºpop())
  760.                                              {
  761.                                                 set("\x01",eval("\x01") - 164);
  762.                                              }
  763.                                           }
  764.                                           else
  765.                                           {
  766.                                              if(eval("\x01") == 841)
  767.                                              {
  768.                                                 break;
  769.                                              }
  770.                                              if(eval("\x01") == 270)
  771.                                              {
  772.                                                 set("\x01",eval("\x01") - 164);
  773.                                                 break loop0;
  774.                                              }
  775.                                              if(eval("\x01") == 106)
  776.                                              {
  777.                                                 set("\x01",eval("\x01") - 49);
  778.                                                 ┬º┬ºpush(true);
  779.                                              }
  780.                                              else if(eval("\x01") == 857)
  781.                                              {
  782.                                                 set("\x01",eval("\x01") - 403);
  783.                                                 ┬º┬ºpush(true);
  784.                                              }
  785.                                              else
  786.                                              {
  787.                                                 if(eval("\x01") != 454)
  788.                                                 {
  789.                                                    if(eval("\x01") == 976)
  790.                                                    {
  791.                                                       set("\x01",eval("\x01") - 856);
  792.                                                       mx.skins.ColoredSkinElement.setColorStyle(this,"themeColor");
  793.                                                    }
  794.                                                    break loop0;
  795.                                                 }
  796.                                                 set("\x01",eval("\x01") - 305);
  797.                                                 if(┬º┬ºpop())
  798.                                                 {
  799.                                                    set("\x01",eval("\x01") + 827);
  800.                                                 }
  801.                                              }
  802.                                           }
  803.                                        }
  804.                                     }
  805.                                  }
  806.                               }
  807.                            }
  808.                         }
  809.                         set("\x01",eval("\x01") - 58);
  810.                         break loop0;
  811.                      }
  812.                      if(eval("\x01") == 203)
  813.                      {
  814.                         set("\x01",eval("\x01") + 645);
  815.                         break loop0;
  816.                      }
  817.                      if(eval("\x01") == 376)
  818.                      {
  819.                         set("\x01",eval("\x01") + 209);
  820.                         break loop0;
  821.                      }
  822.                      if(eval("\x01") == 537)
  823.                      {
  824.                         set("\x01",eval("\x01") - 161);
  825.                         if(┬º┬ºpop())
  826.                         {
  827.                            set("\x01",eval("\x01") + 209);
  828.                         }
  829.                      }
  830.                      else if(eval("\x01") == 550)
  831.                      {
  832.                         set("\x01",eval("\x01") - 375);
  833.                         if(┬º┬ºpop())
  834.                         {
  835.                            set("\x01",eval("\x01") + 488);
  836.                         }
  837.                      }
  838.                      else if(eval("\x01") == 372)
  839.                      {
  840.                         set("\x01",eval("\x01") + 240);
  841.                         ┬º┬ºpush(true);
  842.                      }
  843.                      else
  844.                      {
  845.                         if(eval("\x01") != 393)
  846.                         {
  847.                            break;
  848.                         }
  849.                         set("\x01",eval("\x01") + 493);
  850.                         if(┬º┬ºpop())
  851.                         {
  852.                            set("\x01",eval("\x01") - 43);
  853.                         }
  854.                      }
  855.                      continue;
  856.                   }
  857.                   set("\x01",eval("\x01") + 3);
  858.                   loop13:
  859.                   while(true)
  860.                   {
  861.                      set(┬º┬ºpop(),┬º┬ºpop() - 528);
  862.                      loop14:
  863.                      while(true)
  864.                      {
  865.                         while(true)
  866.                         {
  867.                            if(eval("\x01") == 83)
  868.                            {
  869.                               set("\x01",eval("\x01") + 378);
  870.                               ┬º┬ºpush(true);
  871.                               continue;
  872.                            }
  873.                            if(eval("\x01") == 13)
  874.                            {
  875.                               set("\x01",eval("\x01") + 699);
  876.                               ┬º┬ºpush(┬º┬ºpop().substr(┬º┬ºpop(),┬º┬ºpop()));
  877.                               break loop0;
  878.                            }
  879.                            if(eval("\x01") == 468)
  880.                            {
  881.                               set("\x01",eval("\x01") - 455);
  882.                               if(┬º┬ºpop())
  883.                               {
  884.                                  set("\x01",eval("\x01") + 699);
  885.                               }
  886.                               continue;
  887.                            }
  888.                            if(eval("\x01") == 461)
  889.                            {
  890.                               set("\x01",eval("\x01") + 211);
  891.                               if(┬º┬ºpop())
  892.                               {
  893.                                  set("\x01",eval("\x01") - 145);
  894.                               }
  895.                               continue;
  896.                            }
  897.                            if(eval("\x01") == 430)
  898.                            {
  899.                               set("\x01",eval("\x01") + 211);
  900.                               break loop0;
  901.                            }
  902.                            if(eval("\x01") == 672)
  903.                            {
  904.                               set("\x01",eval("\x01") - 145);
  905.                               break loop0;
  906.                            }
  907.                            if(eval("\x01") == 938)
  908.                            {
  909.                               set("\x01",eval("\x01") - 681);
  910.                               ┬º┬ºpush(true);
  911.                               continue;
  912.                            }
  913.                            if(eval("\x01") == 360)
  914.                            {
  915.                               set("\x01",eval("\x01") - 245);
  916.                               ┬º┬ºpush(true);
  917.                               continue;
  918.                            }
  919.                            if(eval("\x01") == 771)
  920.                            {
  921.                               set("\x01",eval("\x01") - 303);
  922.                               ┬º┬ºpush(true);
  923.                               continue;
  924.                            }
  925.                            if(eval("\x01") != 888)
  926.                            {
  927.                               if(eval("\x01") == 115)
  928.                               {
  929.                                  set("\x01",eval("\x01") + 315);
  930.                                  if(┬º┬ºpop())
  931.                                  {
  932.                                     set("\x01",eval("\x01") + 211);
  933.                                  }
  934.                               }
  935.                               else
  936.                               {
  937.                                  if(eval("\x01") == 359)
  938.                                  {
  939.                                     break;
  940.                                  }
  941.                                  if(eval("\x01") == 510)
  942.                                  {
  943.                                     set("\x01",eval("\x01") - 151);
  944.                                     ┬º┬ºpush(true);
  945.                                  }
  946.                                  else
  947.                                  {
  948.                                     if(eval("\x01") == 919)
  949.                                     {
  950.                                        set("\x01",eval("\x01") - 409);
  951.                                        break loop0;
  952.                                     }
  953.                                     if(eval("\x01") == 361)
  954.                                     {
  955.                                        break loop14;
  956.                                     }
  957.                                     if(eval("\x01") == 277)
  958.                                     {
  959.                                        set("\x01",eval("\x01") + 661);
  960.                                        ┬º┬ºpush({});
  961.                                        break loop0;
  962.                                     }
  963.                                     if(eval("\x01") == 527)
  964.                                     {
  965.                                        set("\x01",eval("\x01") - 439);
  966.                                        ┬º┬ºpush(true);
  967.                                     }
  968.                                     else if(eval("\x01") == 88)
  969.                                     {
  970.                                        set("\x01",eval("\x01") + 831);
  971.                                        if(┬º┬ºpop())
  972.                                        {
  973.                                           set("\x01",eval("\x01") - 409);
  974.                                        }
  975.                                     }
  976.                                     else if(eval("\x01") == 641)
  977.                                     {
  978.                                        set("\x01",eval("\x01") + 240);
  979.                                        ┬º┬ºpush(true);
  980.                                     }
  981.                                     else if(eval("\x01") == 881)
  982.                                     {
  983.                                        set("\x01",eval("\x01") - 604);
  984.                                        if(┬º┬ºpop())
  985.                                        {
  986.                                           set("\x01",eval("\x01") + 661);
  987.                                        }
  988.                                     }
  989.                                     else
  990.                                     {
  991.                                        if(eval("\x01") != 257)
  992.                                        {
  993.                                           if(eval("\x01") == 712)
  994.                                           {
  995.                                              set("\x01",eval("\x01") - 103);
  996.                                              selected = false;
  997.                                              toggle = false;
  998.                                              enabled = true;
  999.                                              visible = true;
  1000.                                              minHeight = 0;
  1001.                                              ┬º┬ºpush("minWidth");
  1002.                                              ┬º┬ºpush(0);
  1003.                                           }
  1004.                                           break loop0;
  1005.                                        }
  1006.                                        set("\x01",eval("\x01") + 104);
  1007.                                        if(┬º┬ºpop())
  1008.                                        {
  1009.                                           set("\x01",eval("\x01") + 410);
  1010.                                        }
  1011.                                     }
  1012.                                  }
  1013.                               }
  1014.                               continue;
  1015.                            }
  1016.                            set("\x01",eval("\x01") - 528);
  1017.                            loop16:
  1018.                            while(true)
  1019.                            {
  1020.                               set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  1021.                               loop17:
  1022.                               while(true)
  1023.                               {
  1024.                                  while(true)
  1025.                                  {
  1026.                                     if(eval("\x01") == 489)
  1027.                                     {
  1028.                                        set("\x01",eval("\x01") - 173);
  1029.                                        ┬º┬ºpush(true);
  1030.                                     }
  1031.                                     else if(eval("\x01") == 620)
  1032.                                     {
  1033.                                        set("\x01",eval("\x01") + 93);
  1034.                                        ┬º┬ºpush(true);
  1035.                                     }
  1036.                                     else if(eval("\x01") == 21)
  1037.                                     {
  1038.                                        set("\x01",eval("\x01") + 223);
  1039.                                        if(┬º┬ºpop())
  1040.                                        {
  1041.                                           set("\x01",eval("\x01") + 477);
  1042.                                        }
  1043.                                     }
  1044.                                     else if(eval("\x01") == 572)
  1045.                                     {
  1046.                                        set("\x01",eval("\x01") - 551);
  1047.                                        ┬º┬ºpush(true);
  1048.                                     }
  1049.                                     else
  1050.                                     {
  1051.                                        if(eval("\x01") == 566)
  1052.                                        {
  1053.                                           set("\x01",eval("\x01") - 539);
  1054.                                           break loop0;
  1055.                                        }
  1056.                                        if(eval("\x01") == 302)
  1057.                                        {
  1058.                                           set("\x01",eval("\x01") + 513);
  1059.                                           ┬º┬ºpush(true);
  1060.                                        }
  1061.                                        else if(eval("\x01") == 225)
  1062.                                        {
  1063.                                           set("\x01",eval("\x01") + 770);
  1064.                                           ┬º┬ºpush(true);
  1065.                                        }
  1066.                                        else
  1067.                                        {
  1068.                                           if(eval("\x01") == 602)
  1069.                                           {
  1070.                                              set("\x01",eval("\x01") - 10);
  1071.                                              ┬º┬ºpop() extends new ┬º┬ºpop()[┬º┬ºpop() >> ┬º┬ºpop()]();
  1072.                                              ┬º┬ºpush(┬º┬ºpop() >>> (┬º┬ºpop() >>> targetPath(┬º┬ºpop())));
  1073.                                              break loop0;
  1074.                                           }
  1075.                                           if(eval("\x01") == 467)
  1076.                                           {
  1077.                                              set("\x01",eval("\x01") + 62);
  1078.                                              ┬º┬ºpush(true);
  1079.                                           }
  1080.                                           else if(eval("\x01") == 316)
  1081.                                           {
  1082.                                              set("\x01",eval("\x01") + 250);
  1083.                                              if(┬º┬ºpop())
  1084.                                              {
  1085.                                                 set("\x01",eval("\x01") - 539);
  1086.                                              }
  1087.                                           }
  1088.                                           else if(eval("\x01") == 713)
  1089.                                           {
  1090.                                              set("\x01",eval("\x01") + 90);
  1091.                                              if(┬º┬ºpop())
  1092.                                              {
  1093.                                                 set("\x01",eval("\x01") - 501);
  1094.                                              }
  1095.                                           }
  1096.                                           else if(eval("\x01") == 815)
  1097.                                           {
  1098.                                              set("\x01",eval("\x01") - 213);
  1099.                                              if(┬º┬ºpop())
  1100.                                              {
  1101.                                                 set("\x01",eval("\x01") - 10);
  1102.                                              }
  1103.                                           }
  1104.                                           else
  1105.                                           {
  1106.                                              if(eval("\x01") == 831)
  1107.                                              {
  1108.                                                 set("\x01",eval("\x01") - 259);
  1109.                                                 break loop0;
  1110.                                              }
  1111.                                              if(eval("\x01") == 995)
  1112.                                              {
  1113.                                                 set("\x01",eval("\x01") - 613);
  1114.                                                 if(┬º┬ºpop())
  1115.                                                 {
  1116.                                                    set("\x01",eval("\x01") + 238);
  1117.                                                 }
  1118.                                              }
  1119.                                              else
  1120.                                              {
  1121.                                                 if(eval("\x01") == 244)
  1122.                                                 {
  1123.                                                    break loop17;
  1124.                                                 }
  1125.                                                 if(eval("\x01") == 817)
  1126.                                                 {
  1127.                                                    set("\x01",eval("\x01") - 66);
  1128.                                                    break loop0;
  1129.                                                 }
  1130.                                                 if(eval("\x01") == 803)
  1131.                                                 {
  1132.                                                    set("\x01",eval("\x01") - 501);
  1133.                                                    break loop0;
  1134.                                                 }
  1135.                                                 if(eval("\x01") == 529)
  1136.                                                 {
  1137.                                                    set("\x01",eval("\x01") + 302);
  1138.                                                    if(┬º┬ºpop())
  1139.                                                    {
  1140.                                                       set("\x01",eval("\x01") - 259);
  1141.                                                    }
  1142.                                                 }
  1143.                                                 else
  1144.                                                 {
  1145.                                                    if(eval("\x01") == 622)
  1146.                                                    {
  1147.                                                       set("\x01",eval("\x01") - 155);
  1148.                                                       break loop0;
  1149.                                                    }
  1150.                                                    if(eval("\x01") == 754)
  1151.                                                    {
  1152.                                                       set("\x01",eval("\x01") - 132);
  1153.                                                       if(┬º┬ºpop())
  1154.                                                       {
  1155.                                                          set("\x01",eval("\x01") - 155);
  1156.                                                       }
  1157.                                                    }
  1158.                                                    else if(eval("\x01") == 592)
  1159.                                                    {
  1160.                                                       set("\x01",eval("\x01") + 162);
  1161.                                                       ┬º┬ºpush(true);
  1162.                                                    }
  1163.                                                    else if(eval("\x01") == 515)
  1164.                                                    {
  1165.                                                       set("\x01",eval("\x01") + 302);
  1166.                                                       if(┬º┬ºpop())
  1167.                                                       {
  1168.                                                          set("\x01",eval("\x01") - 66);
  1169.                                                       }
  1170.                                                    }
  1171.                                                    else
  1172.                                                    {
  1173.                                                       if(eval("\x01") == 825)
  1174.                                                       {
  1175.                                                          set("\x01",eval("\x01") - 600);
  1176.                                                          break loop0;
  1177.                                                       }
  1178.                                                       if(eval("\x01") == 721)
  1179.                                                       {
  1180.                                                          set("\x01",eval("\x01") - 206);
  1181.                                                          ┬º┬ºpush(true);
  1182.                                                       }
  1183.                                                       else
  1184.                                                       {
  1185.                                                          if(eval("\x01") == 382)
  1186.                                                          {
  1187.                                                             set("\x01",eval("\x01") + 238);
  1188.                                                             loop19:
  1189.                                                             while(true)
  1190.                                                             {
  1191.                                                                set(┬º┬ºpop(),┬º┬ºpop());
  1192.                                                                if(┬º┬ºpop())
  1193.                                                                {
  1194.                                                                   set("\x01",eval("\x01") + 962);
  1195.                                                                }
  1196.                                                                while(true)
  1197.                                                                {
  1198.                                                                   if(eval("\x01") == 71)
  1199.                                                                   {
  1200.                                                                      set("\x01",eval("\x01") + 267);
  1201.                                                                      ┬º┬ºpush(true);
  1202.                                                                   }
  1203.                                                                   else if(eval("\x01") == 526)
  1204.                                                                   {
  1205.                                                                      set("\x01",eval("\x01") - 447);
  1206.                                                                      ┬º┬ºpush(true);
  1207.                                                                   }
  1208.                                                                   else
  1209.                                                                   {
  1210.                                                                      if(eval("\x01") == 607)
  1211.                                                                      {
  1212.                                                                         break;
  1213.                                                                      }
  1214.                                                                      if(eval("\x01") == 618)
  1215.                                                                      {
  1216.                                                                         set("\x01",eval("\x01") + 252);
  1217.                                                                         if(┬º┬ºpop())
  1218.                                                                         {
  1219.                                                                            set("\x01",eval("\x01") - 344);
  1220.                                                                         }
  1221.                                                                      }
  1222.                                                                      else
  1223.                                                                      {
  1224.                                                                         if(eval("\x01") == 869)
  1225.                                                                         {
  1226.                                                                            set("\x01",eval("\x01") - 308);
  1227.                                                                            ┬º┬ºpush(┬º┬ºpop()[┬º┬ºpop()]() + 1);
  1228.                                                                            break loop0;
  1229.                                                                         }
  1230.                                                                         if(eval("\x01") == 12)
  1231.                                                                         {
  1232.                                                                            break loop19;
  1233.                                                                         }
  1234.                                                                         if(eval("\x01") == 338)
  1235.                                                                         {
  1236.                                                                            set("\x01",eval("\x01") - 120);
  1237.                                                                            if(┬º┬ºpop())
  1238.                                                                            {
  1239.                                                                               set("\x01",eval("\x01") + 733);
  1240.                                                                            }
  1241.                                                                         }
  1242.                                                                         else
  1243.                                                                         {
  1244.                                                                            if(eval("\x01") == 218)
  1245.                                                                            {
  1246.                                                                               set("\x01",eval("\x01") + 733);
  1247.                                                                               break loop0;
  1248.                                                                            }
  1249.                                                                            if(eval("\x01") == 25)
  1250.                                                                            {
  1251.                                                                               set("\x01",eval("\x01") + 128);
  1252.                                                                               if(┬º┬ºpop())
  1253.                                                                               {
  1254.                                                                                  set("\x01",eval("\x01") + 728);
  1255.                                                                               }
  1256.                                                                            }
  1257.                                                                            else if(eval("\x01") == 951)
  1258.                                                                            {
  1259.                                                                               set("\x01",eval("\x01") - 333);
  1260.                                                                               ┬º┬ºpush(true);
  1261.                                                                            }
  1262.                                                                            else if(eval("\x01") == 79)
  1263.                                                                            {
  1264.                                                                               set("\x01",eval("\x01") + 790);
  1265.                                                                               if(┬º┬ºpop())
  1266.                                                                               {
  1267.                                                                                  set("\x01",eval("\x01") - 308);
  1268.                                                                               }
  1269.                                                                            }
  1270.                                                                            else
  1271.                                                                            {
  1272.                                                                               if(eval("\x01") == 153)
  1273.                                                                               {
  1274.                                                                                  set("\x01",eval("\x01") + 728);
  1275.                                                                                  break loop0;
  1276.                                                                               }
  1277.                                                                               if(eval("\x01") == 870)
  1278.                                                                               {
  1279.                                                                                  set("\x01",eval("\x01") - 344);
  1280.                                                                                  break loop0;
  1281.                                                                               }
  1282.                                                                               if(eval("\x01") == 561)
  1283.                                                                               {
  1284.                                                                                  set("\x01",eval("\x01") - 536);
  1285.                                                                                  ┬º┬ºpush(true);
  1286.                                                                               }
  1287.                                                                               else if(eval("\x01") == 881)
  1288.                                                                               {
  1289.                                                                                  set("\x01",eval("\x01") - 274);
  1290.                                                                                  ┬º┬ºpush(true);
  1291.                                                                               }
  1292.                                                                               else if(eval("\x01") == 974)
  1293.                                                                               {
  1294.                                                                                  set("\x01",eval("\x01") - 952);
  1295.                                                                                  ┬º┬ºpush(true);
  1296.                                                                               }
  1297.                                                                               else if(eval("\x01") == 22)
  1298.                                                                               {
  1299.                                                                                  set("\x01",eval("\x01") + 354);
  1300.                                                                                  if(┬º┬ºpop())
  1301.                                                                                  {
  1302.                                                                                     set("\x01",eval("\x01") + 326);
  1303.                                                                                  }
  1304.                                                                               }
  1305.                                                                               else
  1306.                                                                               {
  1307.                                                                                  if(eval("\x01") == 376)
  1308.                                                                                  {
  1309.                                                                                     set("\x01",eval("\x01") + 326);
  1310.                                                                                     break loop0;
  1311.                                                                                  }
  1312.                                                                                  if(eval("\x01") == 702)
  1313.                                                                                  {
  1314.                                                                                     set("\x01",eval("\x01") - 420);
  1315.                                                                                     ┬º┬ºpush(true);
  1316.                                                                                  }
  1317.                                                                                  else
  1318.                                                                                  {
  1319.                                                                                     if(eval("\x01") != 282)
  1320.                                                                                     {
  1321.                                                                                        if(eval("\x01") == 996)
  1322.                                                                                        {
  1323.                                                                                           set("\x01",eval("\x01") - 782);
  1324.                                                                                           break loop0;
  1325.                                                                                        }
  1326.                                                                                        if(eval("\x01") == 214)
  1327.                                                                                        {
  1328.                                                                                           set("\x01",eval("\x01") + 498);
  1329.                                                                                           stop();
  1330.                                                                                        }
  1331.                                                                                        break loop0;
  1332.                                                                                     }
  1333.                                                                                     set("\x01",eval("\x01") + 714);
  1334.                                                                                     if(┬º┬ºpop())
  1335.                                                                                     {
  1336.                                                                                        set("\x01",eval("\x01") - 782);
  1337.                                                                                     }
  1338.                                                                                  }
  1339.                                                                               }
  1340.                                                                            }
  1341.                                                                         }
  1342.                                                                      }
  1343.                                                                   }
  1344.                                                                }
  1345.                                                             }
  1346.                                                             set("\x01",eval("\x01") + 962);
  1347.                                                             ┬º┬ºpush(!┬º┬ºpop());
  1348.                                                             break loop0;
  1349.                                                          }
  1350.                                                          if(eval("\x01") == 781)
  1351.                                                          {
  1352.                                                             break;
  1353.                                                          }
  1354.                                                          if(eval("\x01") == 462)
  1355.                                                          {
  1356.                                                             set("\x01",eval("\x01") + 319);
  1357.                                                             ┬º┬ºpush(true);
  1358.                                                          }
  1359.                                                          else
  1360.                                                          {
  1361.                                                             if(eval("\x01") == 751)
  1362.                                                             {
  1363.                                                                set("\x01",eval("\x01") - 275);
  1364.                                                                stop();
  1365.                                                                break loop0;
  1366.                                                             }
  1367.                                                             if(eval("\x01") == 795)
  1368.                                                             {
  1369.                                                                set("\x01",eval("\x01") - 333);
  1370.                                                                set(┬º┬ºpop(),┬º┬ºpop() - 605);
  1371.                                                                toggleHighQuality();
  1372.                                                                break loop0;
  1373.                                                             }
  1374.                                                             if(eval("\x01") == 27)
  1375.                                                             {
  1376.                                                                set("\x01",eval("\x01") + 863);
  1377.                                                                ┬º┬ºpush(true);
  1378.                                                             }
  1379.                                                             else
  1380.                                                             {
  1381.                                                                if(eval("\x01") != 890)
  1382.                                                                {
  1383.                                                                   break loop0;
  1384.                                                                }
  1385.                                                                set("\x01",eval("\x01") - 95);
  1386.                                                                if(┬º┬ºpop())
  1387.                                                                {
  1388.                                                                   set("\x01",eval("\x01") - 333);
  1389.                                                                }
  1390.                                                             }
  1391.                                                          }
  1392.                                                       }
  1393.                                                    }
  1394.                                                 }
  1395.                                              }
  1396.                                           }
  1397.                                        }
  1398.                                     }
  1399.                                  }
  1400.                                  set("\x01",eval("\x01") + 44);
  1401.                                  if(!┬º┬ºpop())
  1402.                                  {
  1403.                                     continue;
  1404.                                  }
  1405.                                  continue loop16;
  1406.                               }
  1407.                               set("\x01",eval("\x01") + 477);
  1408.                               break loop0;
  1409.                            }
  1410.                         }
  1411.                         set("\x01",eval("\x01") + 529);
  1412.                         if(!┬º┬ºpop())
  1413.                         {
  1414.                            continue;
  1415.                         }
  1416.                         continue loop13;
  1417.                      }
  1418.                      set("\x01",eval("\x01") + 410);
  1419.                      break loop0;
  1420.                   }
  1421.                }
  1422.             }
  1423.          }
  1424.       }
  1425.    }
  1426.    while(true)
  1427.    {
  1428.       if(eval("\x01") == 451)
  1429.       {
  1430.          set("\x01",eval("\x01") + 167);
  1431.          set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  1432.          break loop0;
  1433.       }
  1434.       if(eval("\x01") == 143)
  1435.       {
  1436.          set("\x01",eval("\x01") + 476);
  1437.          break loop0;
  1438.       }
  1439.       if(eval("\x01") == 995)
  1440.       {
  1441.          set("\x01",eval("\x01") - 106);
  1442.          ┬º┬ºpush(true);
  1443.       }
  1444.       else if(eval("\x01") == 251)
  1445.       {
  1446.          ┬º┬ºgoto(addr2771);
  1447.          ┬º┬ºpush("\x01");
  1448.          ┬º┬ºpush("\x01");
  1449.       }
  1450.       else if(eval("\x01") == 172)
  1451.       {
  1452.          set("\x01",eval("\x01") + 490);
  1453.          ┬º┬ºpush(true);
  1454.       }
  1455.       else
  1456.       {
  1457.          if(eval("\x01") == 335)
  1458.          {
  1459.             set("\x01",eval("\x01") + 660);
  1460.             loop7:
  1461.             while(true)
  1462.             {
  1463.                while(true)
  1464.                {
  1465.                   if(eval("\x01") == 805)
  1466.                   {
  1467.                      set("\x01",eval("\x01") - 532);
  1468.                      ┬º┬ºpush(true);
  1469.                   }
  1470.                   else
  1471.                   {
  1472.                      if(eval("\x01") == 883)
  1473.                      {
  1474.                         set("\x01",eval("\x01") + 54);
  1475.                         prevFrame();
  1476.                         break loop0;
  1477.                      }
  1478.                      if(eval("\x01") == 273)
  1479.                      {
  1480.                         set("\x01",eval("\x01") + 163);
  1481.                         if(┬º┬ºpop())
  1482.                         {
  1483.                            set("\x01",eval("\x01") - 336);
  1484.                         }
  1485.                      }
  1486.                      else
  1487.                      {
  1488.                         if(eval("\x01") == 937)
  1489.                         {
  1490.                            break;
  1491.                         }
  1492.                         if(eval("\x01") == 100)
  1493.                         {
  1494.                            set("\x01",eval("\x01") + 566);
  1495.                            ┬º┬ºpush(true);
  1496.                         }
  1497.                         else if(eval("\x01") == 666)
  1498.                         {
  1499.                            set("\x01",eval("\x01") + 217);
  1500.                            if(┬º┬ºpop())
  1501.                            {
  1502.                               set("\x01",eval("\x01") + 54);
  1503.                            }
  1504.                         }
  1505.                         else if(eval("\x01") == 502)
  1506.                         {
  1507.                            set("\x01",eval("\x01") - 123);
  1508.                            if(┬º┬ºpop())
  1509.                            {
  1510.                               set("\x01",eval("\x01") - 324);
  1511.                            }
  1512.                         }
  1513.                         else if(eval("\x01") == 55)
  1514.                         {
  1515.                            set("\x01",eval("\x01") + 227);
  1516.                            ┬º┬ºpush(true);
  1517.                         }
  1518.                         else
  1519.                         {
  1520.                            if(eval("\x01") == 874)
  1521.                            {
  1522.                               set("\x01",eval("\x01") - 292);
  1523.                               break loop0;
  1524.                            }
  1525.                            if(eval("\x01") == 436)
  1526.                            {
  1527.                               break loop7;
  1528.                            }
  1529.                            if(eval("\x01") == 379)
  1530.                            {
  1531.                               set("\x01",eval("\x01") - 324);
  1532.                               set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  1533.                               break loop0;
  1534.                            }
  1535.                            if(eval("\x01") == 550)
  1536.                            {
  1537.                               set("\x01",eval("\x01") + 2);
  1538.                               break loop0;
  1539.                            }
  1540.                            if(eval("\x01") == 282)
  1541.                            {
  1542.                               set("\x01",eval("\x01") + 592);
  1543.                               if(┬º┬ºpop())
  1544.                               {
  1545.                                  set("\x01",eval("\x01") - 292);
  1546.                               }
  1547.                            }
  1548.                            else if(eval("\x01") == 582)
  1549.                            {
  1550.                               set("\x01",eval("\x01") - 264);
  1551.                               ┬º┬ºpush(true);
  1552.                            }
  1553.                            else
  1554.                            {
  1555.                               if(eval("\x01") != 318)
  1556.                               {
  1557.                                  if(eval("\x01") == 552)
  1558.                                  {
  1559.                                     set("\x01",eval("\x01") - 146);
  1560.                                     stop();
  1561.                                  }
  1562.                                  break loop0;
  1563.                               }
  1564.                               set("\x01",eval("\x01") + 232);
  1565.                               if(┬º┬ºpop())
  1566.                               {
  1567.                                  set("\x01",eval("\x01") + 2);
  1568.                               }
  1569.                            }
  1570.                         }
  1571.                      }
  1572.                   }
  1573.                }
  1574.                set("\x01",eval("\x01") - 435);
  1575.             }
  1576.             set("\x01",eval("\x01") - 336);
  1577.             break loop0;
  1578.          }
  1579.          if(eval("\x01") == 413)
  1580.          {
  1581.             set("\x01",eval("\x01") - 241);
  1582.             ┬º┬ºpush(┬º┬ºpop()());
  1583.             break loop0;
  1584.          }
  1585.          if(eval("\x01") == 639)
  1586.          {
  1587.             set("\x01",eval("\x01") - 226);
  1588.             if(┬º┬ºpop())
  1589.             {
  1590.                set("\x01",eval("\x01") - 241);
  1591.             }
  1592.          }
  1593.          else if(eval("\x01") == 619)
  1594.          {
  1595.             set("\x01",eval("\x01") - 368);
  1596.             ┬º┬ºpush(true);
  1597.          }
  1598.          else if(eval("\x01") == 662)
  1599.          {
  1600.             set("\x01",eval("\x01") - 519);
  1601.             if(┬º┬ºpop())
  1602.             {
  1603.                set("\x01",eval("\x01") + 476);
  1604.             }
  1605.          }
  1606.          else
  1607.          {
  1608.             if(eval("\x01") != 889)
  1609.             {
  1610.                if(eval("\x01") == 618)
  1611.                {
  1612.                   set("\x01",eval("\x01") - 602);
  1613.                }
  1614.                break loop0;
  1615.             }
  1616.             set("\x01",eval("\x01") - 438);
  1617.             if(┬º┬ºpop())
  1618.             {
  1619.                set("\x01",eval("\x01") + 167);
  1620.             }
  1621.          }
  1622.       }
  1623.       ┬º┬ºgoto(addr2706);
  1624.       addr2706:
  1625.    }
  1626. }
  1627.